package com.sykj.cloud.auth.service;


import com.sykj.cloud.common.core.constant.UserConstants;
import com.sykj.cloud.common.core.domain.R;
import com.sykj.cloud.common.core.exception.BaseException;
import com.sykj.cloud.common.core.utils.StringUtils;
import com.sykj.cloud.common.core.utils.ip.IpUtils;
import com.sykj.cloud.common.log.enums.LogErrorType;
import com.sykj.cloud.common.redis.service.RedisService;
import com.sykj.cloud.common.security.utils.SecurityUtils;
import com.sykj.cloud.system.api.RemoteLogService;
import com.sykj.cloud.system.api.RemoteLoggerService;
import com.sykj.cloud.system.api.RemoteUserService;
import com.sykj.cloud.system.api.domain.LogError;
import com.sykj.cloud.system.api.domain.SysUser;
import com.sykj.cloud.system.api.model.LoginUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import static com.sykj.cloud.common.core.constant.Constants.USER_LOGIN_ERROR_COUNT;
import static com.sykj.cloud.common.core.constant.Constants.USER_LOGIN_ERROR_COUNT_LIMIT;

/**
 * 登录校验方法
 *
 * @author ruoyi
 */
@Component
public class SysUserLoginService {

    @Autowired
    RemoteUserService remoteUserService;

    @Autowired
    RedisService redisService;


    @Autowired
    RemoteLogService remoteLogService;

    @Autowired
    RemoteLoggerService loggerService;

    /**
     * 根据用户的日志判断是否需要生成二维码
     */
    public boolean verifyCreateCapcha() {
        // 组装条件，查询登录失败的次数
        Object cacheObject = redisService.getCacheObject(USER_LOGIN_ERROR_COUNT + "_" + IpUtils.getHostIp());
        if (cacheObject == null) {
            return false;
        }
        // 若错误次数超过3次上限，则需要输入验证码，
        if (Integer.parseInt(cacheObject.toString()) > USER_LOGIN_ERROR_COUNT_LIMIT) {
            return true;
        }
        return false;
    }


    /**
     * 增加用户登录失败次数
     */
    void addIpUserLoginErrorCount() {
//        // 组装条件，查询登录失败的次数
//        Object cacheObject = redisService.getCacheObject(USER_LOGIN_ERROR_COUNT + "_" + IpUtils.getHostIp());
//        if (cacheObject != null) {
//            redisService.setCacheObject(USER_LOGIN_ERROR_COUNT + "_" + IpUtils.getHostIp(), Integer.parseInt(cacheObject.toString()) + 1);
//        }else {
//            redisService.setCacheObject(USER_LOGIN_ERROR_COUNT + "_" + IpUtils.getHostIp(), 1);
//        }
    }

    /**
     * 清空用户登录失败次数
     */
    void removeIpUserLoginErrorCount() {
        redisService.deleteObject(USER_LOGIN_ERROR_COUNT + "_" + IpUtils.getHostIp());
    }


    /**
     * 登录
     */
    public LoginUser login(String username, String password){
        // 用户名或密码为空 错误
        if (StringUtils.isAnyBlank(username, password)) {
            addIpUserLoginErrorCount();
            sendLogError(username,"登录用户不存在");
            throw new BaseException("用户名密码必须填写");
        }
        // 密码如果不在指定范围内 错误
        if (password.length() < UserConstants.PASSWORD_MIN_LENGTH
                || password.length() > UserConstants.PASSWORD_MAX_LENGTH) {
            sendLogError(username,"用户名密码不在指定范围");
            addIpUserLoginErrorCount();
            throw new BaseException("用户名密码不在指定范围");
        }
        // 用户名不在指定范围内 错误
        if (username.length() < UserConstants.USERNAME_MIN_LENGTH
                || username.length() > UserConstants.USERNAME_MAX_LENGTH) {
            sendLogError(username,"用户名不在指定范围");
            addIpUserLoginErrorCount();
            throw new BaseException("用户名不在指定范围");
        }
        // 查询用户信息
        R<LoginUser> userResult = remoteUserService.getSysUserInfo(username);

        if (R.FAIL == userResult.getCode()) {
            sendLogError(username,userResult.getMsg());
            addIpUserLoginErrorCount();
            throw new BaseException(userResult.getMsg());
        }

        if (StringUtils.isNull(userResult) || StringUtils.isNull(userResult.getData())) {
            sendLogError(username,"登录用户不存在");
            addIpUserLoginErrorCount();
            throw new BaseException("登录用户：" + username + " 不存在");
        }

        LoginUser userInfo = userResult.getData();
        SysUser user = userResult.getData().getSysUser();
        if (user.getDeleted()==1) {
            sendLogError(username,"账号已被删除");
            addIpUserLoginErrorCount();
            throw new BaseException("对不起，您的账号：" + username + " 已被删除");
        }

        if (user.getValid()==0) {
            sendLogError(username,"用户已停用，请联系管理员");
            addIpUserLoginErrorCount();
            throw new BaseException("对不起，您的账号：" + username + " 已停用");
        }
        if (!SecurityUtils.matchesPassword(password, user.getLoginPassword())) {
            sendLogError(username,"用户名或密码错误");
            addIpUserLoginErrorCount();
            throw new BaseException("用户名或密码错误");
        }


        // 删除 登录错误次数
        removeIpUserLoginErrorCount();
        return userInfo;
    }



    public void sendLogError(String name,String textBody){
        LogError logError=new LogError();
        logError.setLoginName(name);
        logError.setName("用户登录");
        logError.setDescription(textBody);
        logError.setErrorType(LogErrorType.PARAMETER_ERROR.code());
        loggerService.add(logError);

//        Map<String,Object> body=new HashMap<>();
//        body.put("name",name);
//        body.put("msg",textBody);
//
//        Message message=new Message(
//                "loggerTopic",
//                "logger_error",
//                IdUtils.fastSimpleUUID(),
//                body.toString().getBytes());
//        try {
//            rocketMQTemplate.getProducer().send(message);
//        }catch (Exception e){
//            e.printStackTrace();
//        }
    }



}
